home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / Interfaces&Libraries / Universal / Interfaces / PInterfaces / FSM.p < prev    next >
Encoding:
Text File  |  1998-08-17  |  33.8 KB  |  897 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        FSM.p
  3.  
  4.      Contains:    HFS External File System Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1985-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT FSM;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __FSM__}
  27. {$SETC __FSM__ := 1}
  28.  
  29. {$I+}
  30. {$SETC FSMIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __FILES__}
  34. {$I Files.p}
  35. {$ENDC}
  36.  
  37.  
  38. {$PUSH}
  39. {$ALIGN MAC68K}
  40. {$LibExport+}
  41.  
  42. { VolMount declarations are now in Files.≈ }
  43.  
  44. {
  45.  * Miscellaneous file system values not in Files.≈
  46.  }
  47.  
  48. CONST
  49.     fsUsrCNID                    = 16;                            {  First assignable directory or file number  }
  50.                                                                 {     File system trap word attribute bits  }
  51.     kHFSBit                        = 9;                            {  HFS call: bit 9  }
  52.     kHFSMask                    = $0200;
  53.     kAsyncBit                    = 10;                            {  Asynchronous call: bit 10  }
  54.     kAsyncMask                    = $0400;
  55.  
  56.  
  57. {
  58.  * HFSCIProc selectCode values
  59.  * Note: The trap attribute bits (the HFS bit and the asynchronous bit)
  60.  * may be set in these selectCode values.
  61.  }
  62.     kFSMOpen                    = $A000;
  63.     kFSMClose                    = $A001;
  64.     kFSMRead                    = $A002;
  65.     kFSMWrite                    = $A003;
  66.     kFSMGetVolInfo                = $A007;
  67.     kFSMCreate                    = $A008;
  68.     kFSMDelete                    = $A009;
  69.     kFSMOpenRF                    = $A00A;
  70.     kFSMRename                    = $A00B;
  71.     kFSMGetFileInfo                = $A00C;
  72.     kFSMSetFileInfo                = $A00D;
  73.     kFSMUnmountVol                = $A00E;
  74.     kFSMMountVol                = $A00F;
  75.     kFSMAllocate                = $A010;
  76.     kFSMGetEOF                    = $A011;
  77.     kFSMSetEOF                    = $A012;
  78.     kFSMFlushVol                = $A013;
  79.     kFSMGetVol                    = $A014;
  80.     kFSMSetVol                    = $A015;
  81.     kFSMEject                    = $A017;
  82.     kFSMGetFPos                    = $A018;
  83.     kFSMOffline                    = $A035;
  84.     kFSMSetFilLock                = $A041;
  85.     kFSMRstFilLock                = $A042;
  86.     kFSMSetFilType                = $A043;
  87.     kFSMSetFPos                    = $A044;
  88.     kFSMFlushFile                = $A045;                        {     The File System HFSDispatch selectCodes  }
  89.     kFSMOpenWD                    = $0001;
  90.     kFSMCloseWD                    = $0002;
  91.     kFSMCatMove                    = $0005;
  92.     kFSMDirCreate                = $0006;
  93.     kFSMGetWDInfo                = $0007;
  94.     kFSMGetFCBInfo                = $0008;
  95.     kFSMGetCatInfo                = $0009;
  96.     kFSMSetCatInfo                = $000A;
  97.     kFSMSetVolInfo                = $000B;
  98.     kFSMLockRng                    = $0010;
  99.     kFSMUnlockRng                = $0011;
  100.     kFSMXGetVolInfo                = $0012;
  101.     kFSMCreateFileIDRef            = $0014;
  102.     kFSMDeleteFileIDRef            = $0015;
  103.     kFSMResolveFileIDRef        = $0016;
  104.     kFSMExchangeFiles            = $0017;
  105.     kFSMCatSearch                = $0018;
  106.     kFSMOpenDF                    = $001A;
  107.     kFSMMakeFSSpec                = $001B;                        {     The Desktop Manager HFSDispatch selectCodes  }
  108.     kFSMDTGetPath                = $0020;
  109.     kFSMDTCloseDown                = $0021;
  110.     kFSMDTAddIcon                = $0022;
  111.     kFSMDTGetIcon                = $0023;
  112.     kFSMDTGetIconInfo            = $0024;
  113.     kFSMDTAddAPPL                = $0025;
  114.     kFSMDTRemoveAPPL            = $0026;
  115.     kFSMDTGetAPPL                = $0027;
  116.     kFSMDTSetComment            = $0028;
  117.     kFSMDTRemoveComment            = $0029;
  118.     kFSMDTGetComment            = $002A;
  119.     kFSMDTFlush                    = $002B;
  120.     kFSMDTReset                    = $002C;
  121.     kFSMDTGetInfo                = $002D;
  122.     kFSMDTOpenInform            = $002E;
  123.     kFSMDTDelete                = $002F;                        {     The AppleShare HFSDispatch selectCodes  }
  124.     kFSMGetVolParms                = $0030;
  125.     kFSMGetLogInInfo            = $0031;
  126.     kFSMGetDirAccess            = $0032;
  127.     kFSMSetDirAccess            = $0033;
  128.     kFSMMapID                    = $0034;
  129.     kFSMMapName                    = $0035;
  130.     kFSMCopyFile                = $0036;
  131.     kFSMMoveRename                = $0037;
  132.     kFSMOpenDeny                = $0038;
  133.     kFSMOpenRFDeny                = $0039;
  134.     kFSMGetXCatInfo                = $003A;
  135.     kFSMGetVolMountInfoSize        = $003F;
  136.     kFSMGetVolMountInfo            = $0040;
  137.     kFSMVolumeMount                = $0041;
  138.     kFSMShare                    = $0042;
  139.     kFSMUnShare                    = $0043;
  140.     kFSMGetUGEntry                = $0044;
  141.     kFSMGetForeignPrivs            = $0060;
  142.     kFSMSetForeignPrivs            = $0061;
  143.  
  144. {
  145.  * UTDetermineVol status values
  146.  }
  147.     dtmvError                    = 0;                            {  param error  }
  148.     dtmvFullPathame                = 1;                            {  determined by full pathname  }
  149.     dtmvVRefNum                    = 2;                            {  determined by volume refNum  }
  150.     dtmvWDRefNum                = 3;                            {  determined by working directory refNum  }
  151.     dtmvDriveNum                = 4;                            {  determined by drive number  }
  152.     dtmvDefault                    = 5;                            {  determined by default volume  }
  153.  
  154.  
  155. {
  156.  * UTGetBlock options
  157.  }
  158.     gbDefault                    = 0;                            {  default value - read if not found  }
  159.                                                                 {     bits and masks  }
  160.     gbReadBit                    = 0;                            {  read block from disk (forced read)  }
  161.     gbReadMask                    = $0001;
  162.     gbExistBit                    = 1;                            {  get existing cache block  }
  163.     gbExistMask                    = $0002;
  164.     gbNoReadBit                    = 2;                            {  don't read block from disk if not found in cache  }
  165.     gbNoReadMask                = $0004;
  166.     gbReleaseBit                = 3;                            {  release block immediately after GetBlock  }
  167.     gbReleaseMask                = $0008;
  168.  
  169.  
  170. {
  171.  * UTReleaseBlock options
  172.  }
  173.     rbDefault                    = 0;                            {  default value - just mark the buffer not in-use  }
  174.                                                                 {     bits and masks  }
  175.     rbWriteBit                    = 0;                            {  force write buffer to disk  }
  176.     rbWriteMask                    = $0001;
  177.     rbTrashBit                    = 1;                            {  trash buffer contents after release  }
  178.     rbTrashMask                    = $0002;
  179.     rbDirtyBit                    = 2;                            {  mark buffer dirty  }
  180.     rbDirtyMask                    = $0004;
  181.     rbFreeBit                    = 3;                            {  free the buffer (save in the hash)  }
  182.     rbFreeMask                    = $000A;                        {  rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache; on >= System 7.0, rbfreeMask overrides rbTrash  }
  183.  
  184.  
  185. {
  186.  * UTFlushCache options
  187.  }
  188.     fcDefault                    = 0;                            {  default value - pass this fcOption to just flush any dirty buffers  }
  189.                                                                 {     bits and masks  }
  190.     fcTrashBit                    = 0;                            {  (don't pass this as fcOption, use only for testing bit)  }
  191.     fcTrashMask                    = $0001;                        {  pass this fcOption value to flush and trash cache blocks  }
  192.     fcFreeBit                    = 1;                            {  (don't pass this as fcOption, use only for testing bit)  }
  193.     fcFreeMask                    = $0003;                        {  pass this fcOption to flush and free cache blocks (Note: both fcTrash and fcFree bits are set)  }
  194.  
  195.  
  196. {
  197.  * UTCacheReadIP and UTCacheWriteIP cacheOption bits and masks are the ioPosMode
  198.  * bits and masks in Files.x
  199.  }
  200.  
  201. {
  202.  * Cache routine internal error codes
  203.  }
  204.     chNoBuf                        = 1;                            {  no free cache buffers (all in use)  }
  205.     chInUse                        = 2;                            {  requested block in use  }
  206.     chnotfound                    = 3;                            {  requested block not found  }
  207.     chNotInUse                    = 4;                            {  block being released was not in use  }
  208.  
  209.  
  210. {
  211.  * FCBRec.fcbFlags bits
  212.  }
  213.     fcbWriteBit                    = 0;                            {  Data can be written to this file  }
  214.     fcbWriteMask                = $01;
  215.     fcbResourceBit                = 1;                            {  This file is a resource fork  }
  216.     fcbResourceMask                = $02;
  217.     fcbWriteLockedBit            = 2;                            {  File has a locked byte range  }
  218.     fcbWriteLockedMask            = $04;
  219.     fcbSharedWriteBit            = 4;                            {  File is open for shared write access  }
  220.     fcbSharedWriteMask            = $10;
  221.     fcbFileLockedBit            = 5;                            {  File is locked (write-protected)  }
  222.     fcbFileLockedMask            = $20;
  223.     fcbOwnClumpBit                = 6;                            {  File has clump size specified in FCB  }
  224.     fcbOwnClumpMask                = $40;
  225.     fcbModifiedBit                = 7;                            {  File has changed since it was last flushed  }
  226.     fcbModifiedMask                = $80;
  227.  
  228.  
  229. {
  230.  *    HFS Component Interface constants
  231.  }
  232.  
  233. {
  234.  * compInterfMask bits specific to HFS component
  235.  }
  236.     hfsCIDoesHFSBit                = 23;                            {  set if file system supports HFS calls  }
  237.     hfsCIDoesHFSMask            = $00800000;
  238.     hfsCIDoesAppleShareBit        = 22;                            {  set if AppleShare calls supported  }
  239.     hfsCIDoesAppleShareMask        = $00400000;
  240.     hfsCIDoesDeskTopBit            = 21;                            {  set if Desktop Database calls supported  }
  241.     hfsCIDoesDeskTopMask        = $00200000;
  242.     hfsCIDoesDynamicLoadBit        = 20;                            {  set if dynamically loading code resource  }
  243.     hfsCIDoesDynamicLoadMask    = $00100000;                    {         supported  }
  244.     hfsCIResourceLoadedBit        = 19;                            {  set if code resource already loaded  }
  245.     hfsCIResourceLoadedMask        = $00080000;
  246.     hfsCIHasHLL2PProcBit        = 18;                            {  set if FFS' log2PhyProc and Extendfile proc  }
  247.     hfsCIHasHLL2PProcMask        = $00040000;                    {  is written in a high level language. (i.e., uses Pascal calling convention)  }
  248.     hfsCIWantsDTSupportBit        = 17;                            {  set if FFS wants the Mac OS's Desktop Manager code to handle  }
  249.     hfsCIWantsDTSupportMask        = $00020000;                    {  all Desktop Manager requests to its volumes.  }
  250.  
  251.  
  252. {
  253.  *    Disk Initialization Component Interface constants
  254.  }
  255.  
  256. {
  257.  * compInterfMask bits specific to Disk Initialization component
  258.  }
  259.     diCIHasExtFormatParamsBit    = 18;                            {  set if file system needs extended format  }
  260.     diCIHasExtFormatParamsMask    = $00040000;                    {         parameters  }
  261.     diCIHasMultiVolTypesBit        = 17;                            {  set if file system supports more than one  }
  262.     diCIHasMultiVolTypesMask    = $00020000;                    {         volume type  }
  263.     diCIDoesSparingBit            = 16;                            {  set if file system supports disk sparing  }
  264.     diCIDoesSparingMask            = $00010000;
  265.     diCILiveBit                    = 0;                            {  set if file system is candidate for current  }
  266.     diCILiveMask                = $00000001;                    {         formatting operation (set by PACK2)  }
  267.  
  268.  
  269. {
  270.  * Disk Initialization Component Function selectors
  271.  }
  272.     diCILoad                    = 1;                            {  Make initialization code memory resident  }
  273.     diCIUnload                    = 2;                            {  Make initialization code purgeable  }
  274.     diCIEvaluateSizeChoices        = 3;                            {  Evaluate size choices  }
  275.     diCIExtendedZero            = 4;                            {  Write an empty volume directory  }
  276.     diCIValidateVolName            = 5;                            {  Validate volume name  }
  277.     diCIGetVolTypeInfo            = 6;                            {  get volume type info  }
  278.     diCIGetFormatString            = 7;                            {  get dialog format string  }
  279.     diCIGetExtFormatParams        = 8;                            {  get extended format parameters  }
  280.     diCIGetDefectList            = 9;                            {  return the defect list for the indicated disk - reserved for future use  }
  281.  
  282.  
  283. {
  284.  * Constants used in the DICIEvaluateSizeRec and FormatListRec
  285.  }
  286.     diCIFmtListMax                = 8;                            {  maximum number of format list entries in DICIEvaluateSizeRec.numSizeEntries  }
  287.                                                                 {     bits in FormatListRec.formatFlags:  }
  288.     diCIFmtFlagsValidBit        = 7;                            {  set if sec, side, tracks valid  }
  289.     diCIFmtFlagsValidMask        = $80;
  290.     diCIFmtFlagsCurrentBit        = 6;                            {  set if current disk has this fmt  }
  291.     diCIFmtFlagsCurrentMask        = $40;                            {     bits in FormatListRec.sizeListFlags:  }
  292.     diCISizeListOKBit            = 15;                            {  set if this disk size usable  }
  293.     diCISizeListOKMask            = $8000;
  294.  
  295.  
  296. {
  297.  * DICIGetFormatStringRec.stringKind format strings
  298.  }
  299.     diCIAlternateFormatStr        = 1;                            {  get alternate format  string (Balloon Help)  }
  300.     diCISizePresentationStr        = 2;                            {  get size presentation string (for dialog)  }
  301.  
  302.  
  303. {
  304.  * Error codes returned by Disk Sparing
  305.  }
  306.     diCIUserCancelErr            = 1;                            {  user cancelled the disk init  }
  307.     diCICriticalSectorBadErr    = 20;                            {  critical sectors are bad (hopeless)     }
  308.     diCISparingFailedErr        = 21;                            {  disk cannot be spared  }
  309.     diCITooManyBadSectorsErr    = 22;                            {  too many bad sectors  }
  310.     diCIUnknownVolTypeErr        = 23;                            {  the volume type passed in diCIExtendedZero paramBlock is not supported  }
  311.     diCIVolSizeMismatchErr        = 24;                            {  specified volume size doesn’t match with formatted disk size  }
  312.     diCIUnknownDICallErr        = 25;                            {  bogus DI function call selector  }
  313.     diCINoSparingErr            = 26;                            {  disk is bad but the target FS doesn't do disk sparing  }
  314.     diCINoExtendInfoErr            = 27;                            {  missing file system specific extra parameter in diCIExtendedZero call  }
  315.     diCINoMessageTextErr        = 28;                            {  missing message text in DIReformat call  }
  316.  
  317.  
  318. {
  319.  *    File System Manager constants
  320.  }
  321.  
  322. {
  323.  * Miscellaneous constants used by FSM
  324.  }
  325.     fsdVersion1                    = 1;                            {  current version of FSD record  }
  326.     fsmIgnoreFSID                = $FFFE;                        {  this FSID should be ignored by the driver  }
  327.     fsmGenericFSID                = $FFFF;                        {  unknown foreign file system ID  }
  328.  
  329.  
  330. {
  331.  * compInterfMask bits common to all FSM components
  332.  }
  333.     fsmComponentEnableBit        = 31;                            {  set if FSM component interface is enabled  }
  334.     fsmComponentEnableMask        = $80000000;
  335.     fsmComponentBusyBit            = 30;                            {  set if FSM component interface is busy  }
  336.     fsmComponentBusyMask        = $40000000;
  337.  
  338.  
  339. {
  340.  * Selectors for GetFSInfo
  341.  }
  342.     fsmGetFSInfoByIndex            = -1;                            {  get fs info by index  }
  343.     fsmGetFSInfoByFSID            = 0;                            {  get fs info by FSID  }
  344.     fsmGetFSInfoByRefNum        = 1;                            {  get fs info by file/vol refnum  }
  345.  
  346.  
  347. {
  348.  * InformFSM messages
  349.  }
  350.     fsmNopMessage                = 0;                            {  nop  }
  351.     fsmDrvQElChangedMessage        = 1;                            {  DQE has changed  }
  352.     fsmGetFSIconMessage            = 2;                            {  Get FFS's disk icon  }
  353.  
  354.  
  355. {
  356.  * Messages passed to the fileSystemCommProc
  357.  }
  358.     ffsNopMessage                = 0;                            {  nop, should always return noErr  }
  359.     ffsGetIconMessage            = 1;                            {  return disk icon and mask  }
  360.     ffsIDDiskMessage            = 2;                            {  identify the about-to-be-mounted volume  }
  361.     ffsLoadMessage                = 3;                            {  load in the FFS  }
  362.     ffsUnloadMessage            = 4;                            {  unload the FFS  }
  363.     ffsIDVolMountMessage        = 5;                            {  identify a VolMountInfo record  }
  364.     ffsInformMessage            = 6;                            {  FFS defined message  }
  365.     ffsGetIconInfoMessage        = 7;
  366.  
  367.  
  368. {
  369.  * Error codes from FSM functions
  370.  }
  371.     fsmFFSNotFoundErr            = -431;                            {  Foreign File system does not exist - new Pack2 could return this error too  }
  372.     fsmBusyFFSErr                = -432;                            {  File system is busy, cannot be removed  }
  373.     fsmBadFFSNameErr            = -433;                            {  Name length not 1 <= length <= 31  }
  374.     fsmBadFSDLenErr                = -434;                            {  FSD size incompatible with current FSM vers  }
  375.     fsmDuplicateFSIDErr            = -435;                            {  FSID already exists on InstallFS  }
  376.     fsmBadFSDVersionErr            = -436;                            {  FSM version incompatible with FSD  }
  377.     fsmNoAlternateStackErr        = -437;                            {  no alternate stack for HFS CI  }
  378.     fsmUnknownFSMMessageErr        = -438;                            {  unknown message passed to FSM  }
  379.  
  380.  
  381. {
  382.  *    HFS Utility routine records
  383.  }
  384.  
  385. {
  386.  * record used by UTGetPathComponentName
  387.  }
  388.  
  389. TYPE
  390.     ParsePathRecPtr = ^ParsePathRec;
  391.     ParsePathRec = RECORD
  392.         namePtr:                StringPtr;                                {  pathname to parse  }
  393.         startOffset:            INTEGER;                                {  where to start parsing  }
  394.         componentLength:        INTEGER;                                {  the length of the pathname component parsed  }
  395.         moreName:                SignedByte;                                {  non-zero if there are more components after this one  }
  396.         foundDelimiter:            SignedByte;                                {  non-zero if parsing stopped because a colon (:) delimiter was found  }
  397.     END;
  398.  
  399.     WDCBRecPtr = ^WDCBRec;
  400.     WDCBRec = RECORD
  401.         wdVCBPtr:                VCBPtr;                                    {  Pointer to VCB of this working directory  }
  402.         wdDirID:                LONGINT;                                {  Directory ID number of this working directory  }
  403.         wdCatHint:                LONGINT;                                {  Hint for finding this working directory  }
  404.         wdProcID:                LONGINT;                                {  Process that created this working directory  }
  405.     END;
  406.  
  407.     FCBRecPtr = ^FCBRec;
  408.     FCBRec = RECORD
  409.         fcbFlNm:                UInt32;                                    {  FCB file number. Non-zero marks FCB used  }
  410.         fcbFlags:                SignedByte;                                {  FCB flags  }
  411.         fcbTypByt:                SignedByte;                                {  File type byte  }
  412.         fcbSBlk:                UInt16;                                    {  File start block (in alloc size blks)  }
  413.         fcbEOF:                    UInt32;                                    {  Logical length or EOF in bytes  }
  414.         fcbPLen:                UInt32;                                    {  Physical file length in bytes  }
  415.         fcbCrPs:                UInt32;                                    {  Current position within file  }
  416.         fcbVPtr:                VCBPtr;                                    {  Pointer to the corresponding VCB  }
  417.         fcbBfAdr:                Ptr;                                    {  File's buffer address  }
  418.         fcbFlPos:                UInt16;                                    {  Directory block this file is in  }
  419.                                                                         {  FCB Extensions for HFS  }
  420.         fcbClmpSize:            UInt32;                                    {  Number of bytes per clump  }
  421.         fcbBTCBPtr:                Ptr;                                    {  Pointer to B*-Tree control block for file  }
  422.         fcbExtRec:                ARRAY [0..2] OF UInt32;                    {  First 3 file extents  }
  423.         fcbFType:                OSType;                                    {  File's 4 Finder Type bytes  }
  424.         fcbCatPos:                UInt32;                                    {  Catalog hint for use on Close  }
  425.         fcbDirID:                UInt32;                                    {  Parent Directory ID  }
  426.         fcbCName:                Str31;                                    {  CName of open file  }
  427.     END;
  428.  
  429. {
  430.  *    HFS Component Interface records
  431.  }
  432. {$IFC TYPED_FUNCTION_POINTERS}
  433.     Lg2PhysProcPtr = FUNCTION(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: UInt32; reqCount: UInt32; VAR volOffset: UInt32; VAR contiguousBytes: UInt32): OSErr;
  434. {$ELSEC}
  435.     Lg2PhysProcPtr = ProcPtr;
  436. {$ENDC}
  437.  
  438.     Lg2PhysUPP = UniversalProcPtr;
  439.  
  440. CONST
  441.     uppLg2PhysProcInfo = $003FEFE0;
  442.  
  443. FUNCTION NewLg2PhysProc(userRoutine: Lg2PhysProcPtr): Lg2PhysUPP;
  444.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  445.     INLINE $2E9F;
  446.     {$ENDC}
  447.  
  448. FUNCTION CallLg2PhysProc(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: UInt32; reqCount: UInt32; VAR volOffset: UInt32; VAR contiguousBytes: UInt32; userRoutine: Lg2PhysUPP): OSErr;
  449.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  450.     INLINE $205F, $4E90;
  451.     {$ENDC}
  452.  
  453. TYPE
  454. {$IFC TYPED_FUNCTION_POINTERS}
  455.     HFSCIProcPtr = FUNCTION(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER): OSErr;
  456. {$ELSEC}
  457.     HFSCIProcPtr = ProcPtr;
  458. {$ENDC}
  459.  
  460.     HFSCIUPP = UniversalProcPtr;
  461.  
  462. CONST
  463.     uppHFSCIProcInfo = $0000BEE0;
  464.  
  465. FUNCTION NewHFSCIProc(userRoutine: HFSCIProcPtr): HFSCIUPP;
  466.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  467.     INLINE $2E9F;
  468.     {$ENDC}
  469.  
  470. FUNCTION CallHFSCIProc(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER; userRoutine: HFSCIUPP): OSErr;
  471.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  472.     INLINE $205F, $4E90;
  473.     {$ENDC}
  474.  
  475. TYPE
  476.     HFSCIRecPtr = ^HFSCIRec;
  477.     HFSCIRec = RECORD
  478.         compInterfMask:            LONGINT;                                {  component flags  }
  479.         compInterfProc:            HFSCIUPP;                                {  pointer to file system call processing code  }
  480.         log2PhyProc:            Lg2PhysUPP;                                {  pointer to Lg2PhysProc() code  }
  481.         stackTop:                Ptr;                                    {  file system stack top  }
  482.         stackSize:                LONGINT;                                {  file system stack size  }
  483.         stackPtr:                Ptr;                                    {  current file system stack pointer  }
  484.         reserved3:                LONGINT;                                {  --reserved, must be zero--  }
  485.         idSector:                LONGINT;                                {  Sector you need to ID a local volume. For networked volumes, this must be -1  }
  486.         reserved2:                LONGINT;                                {  --reserved, must be zero--  }
  487.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  488.     END;
  489.  
  490. {
  491.  *    Disk Initialization Component Interface records
  492.  }
  493. {$IFC TYPED_FUNCTION_POINTERS}
  494.     DICIProcPtr = FUNCTION(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr): OSErr;
  495. {$ELSEC}
  496.     DICIProcPtr = ProcPtr;
  497. {$ENDC}
  498.  
  499.     DICIUPP = UniversalProcPtr;
  500.  
  501. CONST
  502.     uppDICIProcInfo = $00000FA0;
  503.  
  504. FUNCTION NewDICIProc(userRoutine: DICIProcPtr): DICIUPP;
  505.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  506.     INLINE $2E9F;
  507.     {$ENDC}
  508.  
  509. FUNCTION CallDICIProc(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; userRoutine: DICIUPP): OSErr;
  510.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  511.     INLINE $205F, $4E90;
  512.     {$ENDC}
  513.  
  514. TYPE
  515.     DICIRecPtr = ^DICIRec;
  516.     DICIRec = RECORD
  517.         compInterfMask:            LONGINT;                                {  component flags  }
  518.         compInterfProc:            DICIUPP;                                {  pointer to call processing code  }
  519.         maxVolNameLength:        INTEGER;                                {  maximum length of your volume name  }
  520.         blockSize:                UInt16;                                    {  your file system's block size  }
  521.         reserved3:                LONGINT;                                {  --reserved, must be zero--  }
  522.         reserved2:                LONGINT;                                {  --reserved, must be zero--  }
  523.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  524.     END;
  525.  
  526. {
  527.  * FormatListRec as returned by the .Sony disk driver's
  528.  * Return Format List status call (csCode = 6).
  529.  * If the status call to get this list for a drive is not
  530.  * implemented by the driver, then a list with one entry
  531.  * is contructed from the drive queue element for the drive.
  532.  }
  533.     FormatListRecPtr = ^FormatListRec;
  534.     FormatListRec = RECORD
  535.         volSize:                UInt32;                                    {  disk capacity in SECTORs  }
  536.         formatFlags:            SignedByte;                                {  flags  }
  537.         sectorsPerTrack:        SignedByte;                                {  sectors per track side  }
  538.         tracks:                    UInt16;                                    {  number of tracks  }
  539.     END;
  540.  
  541. {
  542.  * SizeListRec built from FormatListRecs as described above.
  543.  }
  544.     SizeListRecPtr = ^SizeListRec;
  545.     SizeListRec = RECORD
  546.         sizeListFlags:            INTEGER;                                {  flags as set by external file system  }
  547.         sizeEntry:                FormatListRec;                            {  disk driver format list record  }
  548.     END;
  549.  
  550. {
  551.  * paramBlock for the diCIEvaluateSize call
  552.  }
  553.     DICIEvaluateSizeRecPtr = ^DICIEvaluateSizeRec;
  554.     DICIEvaluateSizeRec = RECORD
  555.         defaultSizeIndex:        INTEGER;                                {  default size for this FS  }
  556.         numSizeEntries:            INTEGER;                                {  number of size entries  }
  557.         driveNumber:            INTEGER;                                {  drive number  }
  558.         sizeListPtr:            SizeListRecPtr;                            {  ptr to size entry table  }
  559.         sectorSize:                UInt16;                                    {  bytes per sector  }
  560.     END;
  561.  
  562. {
  563.  * paramBlock for the diCIExtendedZero call
  564.  }
  565.     DICIExtendedZeroRecPtr = ^DICIExtendedZeroRec;
  566.     DICIExtendedZeroRec = RECORD
  567.         driveNumber:            INTEGER;                                {  drive number  }
  568.         volNamePtr:                StringPtr;                                {  ptr to volume name string  }
  569.         fsid:                    INTEGER;                                {  file system ID  }
  570.         volTypeSelector:        INTEGER;                                {  volume type selector, if supports more than 1 type  }
  571.         numDefectBlocks:        UInt16;                                    {  number of bad logical blocks  }
  572.         defectListSize:            UInt16;                                    {  size of the defect list buffer in bytes  }
  573.         defectListPtr:            Ptr;                                    {  pointer to defect list buffer  }
  574.         volSize:                UInt32;                                    {  size of volume in SECTORs  }
  575.         sectorSize:                UInt16;                                    {  bytes per sector  }
  576.         extendedInfoPtr:        Ptr;                                    {  ptr to extended info  }
  577.     END;
  578.  
  579. {
  580.  * paramBlock for the diCIValidateVolName call
  581.  }
  582.     DICIValidateVolNameRecPtr = ^DICIValidateVolNameRec;
  583.     DICIValidateVolNameRec = PACKED RECORD
  584.         theChar:                CHAR;                                    {  the character to validate  }
  585.         hasMessageBuffer:        BOOLEAN;                                {  false if no message  }
  586.         charOffset:                INTEGER;                                {  position of the current character (first char = 1)  }
  587.         messageBufferPtr:        StringPtr;                                {  pointer to message buffer or nil  }
  588.         charByteType:            INTEGER;                                {  theChar's byte type (smSingleByte, smFirstByte, or smLastByte)  }
  589.     END;
  590.  
  591. {
  592.  * paramBlock for the diCIGetVolTypeInfo call
  593.  }
  594.     DICIGetVolTypeInfoRecPtr = ^DICIGetVolTypeInfoRec;
  595.     DICIGetVolTypeInfoRec = RECORD
  596.         volSize:                UInt32;                                    {  size of volume in SECTORs  }
  597.         sectorSize:                UInt16;                                    {  bytes per sector  }
  598.         numVolTypes:            INTEGER;                                {  number of volume types supported  }
  599.         volTypesBuffer:            ARRAY [0..3] OF Str31;                    {  4 string buffers  }
  600.     END;
  601.  
  602. {
  603.  * paramBlock for the diCIGetFormatString call
  604.  }
  605.     DICIGetFormatStringRecPtr = ^DICIGetFormatStringRec;
  606.     DICIGetFormatStringRec = RECORD
  607.         volSize:                UInt32;                                    {  volume size in SECTORs  }
  608.         sectorSize:                UInt16;                                    {  sector size  }
  609.         volTypeSelector:        INTEGER;                                {  volume type selector  }
  610.         stringKind:                INTEGER;                                {  sub-function = type of string  }
  611.         stringBuffer:            Str255;                                    {  string buffer  }
  612.     END;
  613.  
  614. {
  615.  * paramBlock for the diCIGetExtendedFormatParams call
  616.  }
  617.     DICIGetExtendedFormatRecPtr = ^DICIGetExtendedFormatRec;
  618.     DICIGetExtendedFormatRec = RECORD
  619.         driveNumber:            INTEGER;                                {  drive number  }
  620.         volTypeSelector:        INTEGER;                                {  volume type selector or 0  }
  621.         volSize:                UInt32;                                    {  size of volume in SECTORs  }
  622.         sectorSize:                UInt16;                                    {  bytes per sector  }
  623.         fileSystemSpecPtr:        FSSpecPtr;                                {  pointer to the foreign file system's FSSpec  }
  624.         extendedInfoPtr:        Ptr;                                    {  pointer to extended parameter structure  }
  625.     END;
  626.  
  627. {
  628.  *    File System Manager records
  629.  }
  630.  
  631. {$IFC TYPED_FUNCTION_POINTERS}
  632.     FSDCommProcPtr = FUNCTION(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr): OSErr;
  633. {$ELSEC}
  634.     FSDCommProcPtr = ProcPtr;
  635. {$ENDC}
  636.  
  637.     FSDCommUPP = UniversalProcPtr;
  638.  
  639. CONST
  640.     uppFSDCommProcInfo = $00000FA0;
  641.  
  642. FUNCTION NewFSDCommProc(userRoutine: FSDCommProcPtr): FSDCommUPP;
  643.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  644.     INLINE $2E9F;
  645.     {$ENDC}
  646.  
  647. FUNCTION CallFSDCommProc(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr; userRoutine: FSDCommUPP): OSErr;
  648.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  649.     INLINE $205F, $4E90;
  650.     {$ENDC}
  651.  
  652. TYPE
  653.     FSDRecPtr = ^FSDRec;
  654.     FSDRec = RECORD
  655.         fsdLink:                FSDRecPtr;                                {  ptr to next  }
  656.         fsdLength:                INTEGER;                                {  length of this FSD in BYTES  }
  657.         fsdVersion:                INTEGER;                                {  version number  }
  658.         fileSystemFSID:            INTEGER;                                {  file system id  }
  659.         fileSystemName:            Str31;                                    {  file system name  }
  660.         fileSystemSpec:            FSSpec;                                    {  foreign file system's FSSpec  }
  661.         fileSystemGlobalsPtr:    Ptr;                                    {  ptr to file system globals  }
  662.         fileSystemCommProc:        FSDCommUPP;                                {  communication proc with the FFS  }
  663.         reserved3:                LONGINT;                                {  --reserved, must be zero--  }
  664.         reserved2:                LONGINT;                                {  --reserved, must be zero--  }
  665.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  666.         fsdHFSCI:                HFSCIRec;                                {  HFS component interface     }
  667.         fsdDICI:                DICIRec;                                {  Disk Initialization component interface  }
  668.     END;
  669.  
  670.     FSMGetIconInfoRecPtr = ^FSMGetIconInfoRec;
  671.     FSMGetIconInfoRec = RECORD
  672.         theIcon:                ARRAY [0..31] OF LONGINT;                {  The ICN# structure  }
  673.         theMask:                ARRAY [0..31] OF LONGINT;                {  The mask for the icon above  }
  674.         whereStr:                Str255;
  675.     END;
  676.  
  677. {
  678.  * paramBlock for ffsGetIconMessage and fsmGetFSIconMessage
  679.  }
  680.     FSMGetIconRecPtr = ^FSMGetIconRec;
  681.     FSMGetIconRec = RECORD
  682.         refNum:                    INTEGER;                                {  target drive num or volume refnum  }
  683.         iconBufferPtr:            FSMGetIconInfoRecPtr;                    {  pointer to icon buffer  }
  684.         requestSize:            LONGINT;                                {  requested size of the icon buffer  }
  685.         actualSize:                LONGINT;                                {  actual size of the icon data returned  }
  686.         iconType:                SInt8;                                    {  kind of icon  }
  687.         isEjectable:            BOOLEAN;                                {  true if the device is ejectable  }
  688.         driveQElemPtr:            DrvQElPtr;                                {  pointer to DQE  }
  689.         fileSystemSpecPtr:        FSSpecPtr;                                {  pointer to foreign file system's FSSpec  }
  690.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  691.     END;
  692.  
  693. {
  694.  *    HFS Utility routine prototypes
  695.  }
  696. FUNCTION UTAllocateFCB(VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  697.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  698.     INLINE $7000, $A824;
  699.     {$ENDC}
  700. FUNCTION UTReleaseFCB(fileRefNum: INTEGER): OSErr;
  701.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  702.     INLINE $7001, $A824;
  703.     {$ENDC}
  704. FUNCTION UTLocateFCB(volCtrlBlockPtr: VCBPtr; fileNum: UInt32; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  705.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  706.     INLINE $7002, $A824;
  707.     {$ENDC}
  708. FUNCTION UTLocateNextFCB(volCtrlBlockPtr: VCBPtr; fileNum: UInt32; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  709.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  710.     INLINE $7003, $A824;
  711.     {$ENDC}
  712. FUNCTION UTIndexFCB(volCtrlBlockPtr: VCBPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  713.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  714.     INLINE $7004, $A824;
  715.     {$ENDC}
  716. FUNCTION UTResolveFCB(fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  717.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  718.     INLINE $7005, $A824;
  719.     {$ENDC}
  720. FUNCTION UTAllocateVCB(VAR sysVCBLength: UInt16; VAR volCtrlBlockPtr: VCBPtr; addSize: UInt16): OSErr;
  721.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  722.     INLINE $7006, $A824;
  723.     {$ENDC}
  724. FUNCTION UTAddNewVCB(driveNum: INTEGER; VAR vRefNum: INTEGER; volCtrlBlockPtr: VCBPtr): OSErr;
  725.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  726.     INLINE $7007, $A824;
  727.     {$ENDC}
  728. FUNCTION UTDisposeVCB(volCtrlBlockPtr: VCBPtr): OSErr;
  729.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  730.     INLINE $7008, $A824;
  731.     {$ENDC}
  732. FUNCTION UTLocateVCBByRefNum(refNum: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  733.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  734.     INLINE $7009, $A824;
  735.     {$ENDC}
  736. FUNCTION UTLocateVCBByName(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  737.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  738.     INLINE $700A, $A824;
  739.     {$ENDC}
  740. FUNCTION UTLocateNextVCB(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  741.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  742.     INLINE $700B, $A824;
  743.     {$ENDC}
  744. FUNCTION UTAllocateWDCB(paramBlock: WDPBPtr): OSErr;
  745.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  746.     INLINE $700C, $A824;
  747.     {$ENDC}
  748. FUNCTION UTReleaseWDCB(wdRefNum: INTEGER): OSErr;
  749.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  750.     INLINE $700D, $A824;
  751.     {$ENDC}
  752. FUNCTION UTResolveWDCB(procID: LONGINT; wdIndex: INTEGER; wdRefNum: INTEGER; VAR wdCtrlBlockPtr: WDCBRecPtr): OSErr;
  753.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  754.     INLINE $700E, $A824;
  755.     {$ENDC}
  756. FUNCTION UTFindDrive(driveNum: INTEGER; VAR driveQElementPtr: DrvQElPtr): OSErr;
  757.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  758.     INLINE $700F, $A824;
  759.     {$ENDC}
  760. FUNCTION UTAdjustEOF(fileRefNum: INTEGER): OSErr;
  761.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  762.     INLINE $7010, $A824;
  763.     {$ENDC}
  764. FUNCTION UTSetDefaultVol(nodeHint: LONGINT; dirID: UInt32; refNum: INTEGER): OSErr;
  765.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  766.     INLINE $7011, $A824;
  767.     {$ENDC}
  768. FUNCTION UTGetDefaultVol(paramBlock: WDPBPtr): OSErr;
  769.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  770.     INLINE $7012, $A824;
  771.     {$ENDC}
  772. FUNCTION UTEjectVol(volCtrlBlockPtr: VCBPtr): OSErr;
  773.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  774.     INLINE $702B, $A824;
  775.     {$ENDC}
  776. FUNCTION UTCheckWDRefNum(wdRefNum: INTEGER): OSErr;
  777.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  778.     INLINE $7013, $A824;
  779.     {$ENDC}
  780. FUNCTION UTCheckFileRefNum(fileRefNum: INTEGER): OSErr;
  781.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  782.     INLINE $7014, $A824;
  783.     {$ENDC}
  784. FUNCTION UTCheckVolRefNum(vRefNum: INTEGER): OSErr;
  785.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  786.     INLINE $7015, $A824;
  787.     {$ENDC}
  788. FUNCTION UTCheckPermission(volCtrlBlockPtr: VCBPtr; VAR modByte: INTEGER; fileNum: UInt32; paramBlock: ParmBlkPtr): OSErr;
  789.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  790.     INLINE $7016, $A824;
  791.     {$ENDC}
  792. FUNCTION UTCheckVolOffline(vRefNum: INTEGER): OSErr;
  793.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  794.     INLINE $7017, $A824;
  795.     {$ENDC}
  796. FUNCTION UTCheckVolModifiable(vRefNum: INTEGER): OSErr;
  797.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  798.     INLINE $7018, $A824;
  799.     {$ENDC}
  800. FUNCTION UTCheckFileModifiable(fileRefNum: INTEGER): OSErr;
  801.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  802.     INLINE $7019, $A824;
  803.     {$ENDC}
  804. FUNCTION UTCheckDirBusy(volCtrlBlockPtr: VCBPtr; dirID: UInt32): OSErr;
  805.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  806.     INLINE $701A, $A824;
  807.     {$ENDC}
  808. FUNCTION UTParsePathname(VAR volNamelength: INTEGER; namePtr: StringPtr): OSErr;
  809.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  810.     INLINE $701B, $A824;
  811.     {$ENDC}
  812. FUNCTION UTGetPathComponentName(parseRec: ParsePathRecPtr): OSErr;
  813.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  814.     INLINE $701C, $A824;
  815.     {$ENDC}
  816. FUNCTION UTDetermineVol(paramBlock: ParmBlkPtr; VAR status: INTEGER; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  817.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  818.     INLINE $701D, $A824;
  819.     {$ENDC}
  820. FUNCTION UTGetBlock(refNum: INTEGER; log2PhyProc: UNIV Ptr; blockNum: UInt32; gbOption: INTEGER; VAR buffer: Ptr): OSErr;
  821.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  822.     INLINE $701F, $A824;
  823.     {$ENDC}
  824. FUNCTION UTReleaseBlock(buffer: Ptr; rbOption: INTEGER): OSErr;
  825.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  826.     INLINE $7020, $A824;
  827.     {$ENDC}
  828. FUNCTION UTFlushCache(refNum: INTEGER; fcOption: INTEGER): OSErr;
  829.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  830.     INLINE $7021, $A824;
  831.     {$ENDC}
  832. FUNCTION UTMarkDirty(buffer: Ptr): OSErr;
  833.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  834.     INLINE $7023, $A824;
  835.     {$ENDC}
  836. FUNCTION UTTrashVolBlocks(volCtrlBlockPtr: VCBPtr): OSErr;
  837.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  838.     INLINE $7024, $A824;
  839.     {$ENDC}
  840. FUNCTION UTTrashFileBlocks(volCtrlBlockPtr: VCBPtr; fileNum: UInt32): OSErr;
  841.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  842.     INLINE $7025, $A824;
  843.     {$ENDC}
  844. FUNCTION UTTrashBlocks(beginPosition: UInt32; byteCount: UInt32; volCtrlBlockPtr: VCBPtr; fileRefNum: INTEGER; tbOption: INTEGER): OSErr;
  845.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  846.     INLINE $7026, $A824;
  847.     {$ENDC}
  848. FUNCTION UTCacheReadIP(log2PhyProc: UNIV Ptr; filePosition: UInt32; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: UInt32; VAR actCount: UInt32; cacheOption: INTEGER): OSErr;
  849.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  850.     INLINE $7027, $A824;
  851.     {$ENDC}
  852. FUNCTION UTCacheWriteIP(log2PhyProc: UNIV Ptr; filePosition: UInt32; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: UInt32; VAR actCount: UInt32; cacheOption: INTEGER): OSErr;
  853.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  854.     INLINE $7028, $A824;
  855.     {$ENDC}
  856. FUNCTION UTBlockInFQHashP(vRefNum: INTEGER; diskBlock: UInt32): OSErr;
  857.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  858.     INLINE $702C, $A824;
  859.     {$ENDC}
  860. FUNCTION UTVolCacheReadIP(volCtrlBlockPtr: VCBPtr; blockPosition: UInt32; ioBuffer: Ptr; reqCount: UInt32; VAR actCount: UInt32; cacheOption: INTEGER): OSErr;
  861.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  862.     INLINE $7034, $A824;
  863.     {$ENDC}
  864. FUNCTION UTVolCacheWriteIP(volCtrlBlockPtr: VCBPtr; blockPosition: UInt32; ioBuffer: Ptr; reqCount: UInt32; VAR actCount: UInt32; cacheOption: INTEGER): OSErr;
  865.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  866.     INLINE $7035, $A824;
  867.     {$ENDC}
  868.  
  869.  
  870. {
  871.  *    File System Manager call prototypes
  872.  }
  873. FUNCTION InstallFS(fsdPtr: FSDRecPtr): OSErr;
  874.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  875.     INLINE $205F, $7000, $A0AC, $3E80;
  876.     {$ENDC}
  877. FUNCTION RemoveFS(fsid: INTEGER): OSErr;
  878.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  879.     INLINE $305F, $7001, $A0AC, $3E80;
  880.     {$ENDC}
  881. FUNCTION SetFSInfo(fsid: INTEGER; bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  882. FUNCTION GetFSInfo(selector: INTEGER; key: INTEGER; VAR bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  883. FUNCTION InformFSM(theMessage: INTEGER; paramBlock: UNIV Ptr): OSErr;
  884. FUNCTION InformFFS(fsid: INTEGER; paramBlock: UNIV Ptr): OSErr;
  885.  
  886.  
  887. {$ALIGN RESET}
  888. {$POP}
  889.  
  890. {$SETC UsingIncludes := FSMIncludes}
  891.  
  892. {$ENDC} {__FSM__}
  893.  
  894. {$IFC NOT UsingIncludes}
  895.  END.
  896. {$ENDC}
  897.